package com.gitee.yongzhuzl.commonutil.util.string;

import com.gitee.yongzhuzl.commonutil.util.date.CalendarUtil;
import com.gitee.yongzhuzl.commonutil.util.empty.EmptyUtil;
import com.gitee.yongzhuzl.commonutil.util.transfer.TransferTool;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Objects;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * description: String工具类，对字符串进行操作以达到我们更方便使用的目的
 * @author 朱正磊
 * @date 2018年5月23日 上午11:13:31
 */
public class StringUtil {

    private static final Logger log = LoggerFactory.getLogger(StringUtil.class);

    /**
     * Integer类型
     */
    public final static String INTEGER = "INTEGER";

    /**
     * Float类型
     */
    public final static String FLOAT = "FLOAT";

    /**
     * 只有日期没有时间
     */
    public final static String DATE = "DATE";

    /**
     * 既有日期也有时间
     */
    public final static String DATETIME = "DATETIME";

    /**
     * 布尔类型
     */
    public final static String BOOLEAN = "BOOLEAN";

    /**
     * description: 获取唯一随机数UUID，比如：539b34659ae3431c804d02bae470bd72（32个字符）
     * @return 返回32位uuid字符串
     */
    public static String getUuid() {
        return UUID.randomUUID().toString().replace("-", "");
    }

    /**
     * description: 统计字符串中某个子字符串出现的次数
     * @param str 字符串
     * @param subStr 子字符串
     * @return 返回字符串中某个子字符串出现的次数
     */
    public static Integer count(String str, String subStr) {
        if (!str.contains(subStr)) {
            return 0;
        } else if (Objects.equals(str, subStr)) {
            return 1;
        } else if (str.endsWith(subStr)) {
            return (str.split(subStr)).length;
        } else {
            return (str.split(subStr)).length - 1;
        }
    }

    /**
     * 说明：获取某个子字符串在整个字符串中第N次出现时的下标索引（正着数第N次）
     * description: 子字符串modelStr在字符串str中第count次出现时的下标（正着数第count次）
     * @param str 字符串str
     * @param modelStr 子字符串modelStr
     * @param count 第count次出现（正着数）
     * @return 下标
     */
    public static Integer getFromIndex(String str, String modelStr, Integer count) {
        // 对子字符串进行匹配
        Matcher slashMatcher = Pattern.compile(modelStr).matcher(str);
        int index = 0;
        // matcher.find();尝试查找与该模式匹配的输入序列的下一个子序列
        while (slashMatcher.find()) {
            index++;
            // 当modelStr字符第count次出现的位置
            if (index == count) {
                break;
            }
        }
        // matcher.start();返回以前匹配的初始索引。
        return slashMatcher.start();
    }

    /**
     * 说明：获取某个子字符串在整个字符串中第N次出现时的下标索引（倒着数第N次）
     * description: 子字符串modelStr在字符串str中第count次出现时的下标（倒着数第count次）
     * @param str 字符串str
     * @param modelStr 子字符串modelStr
     * @param count 第count次出现（倒着数）
     * @return 下标
     */
    public static Integer getLastIndex(String str, String modelStr, Integer count) {
        for (int i = count; i >= 1; i--) {
            int lastIndex = str.lastIndexOf(modelStr);
            str = str.substring(0, lastIndex);
        }
        return str.length();
    }

    /**
     * description: 判断字符串的长度是否在[min, max]范围内
     * @param content 字符串
     * @param min 最小长度
     * @param max 最大长度
     * @return 如果不在指定范围内返回false，否则返回true
     */
    public static Boolean validateLength(String content, Integer min, Integer max) {
        int length = content.length();
        return length >= min && length <= max;
    }

    /**
     * description: 判断字符串的长度是否在[0, max]范围内
     * @param content 字符串
     * @param max 最大长度
     * @return 如果不在指定范围内返回false，否则返回true
     */
    public static Boolean validateLength(String content, Integer max) {
        return validateLength(content, 0, max);
    }

    /**
     * description: 如果参数为blank，那么返回""，如果不为blank，那么返回参数的字符串类型
     * @param object 参数
     * @return 返回字符串
     */
    public static String checkBlankToString(Object object) {
        return atLeastOneIsBlank(object) ? "" : object.toString();
    }

    /**
     * description: 如果参数为blank，那么返回blankToString，如果不为blank，那么返回参数的字符串类型
     * @param object 参数
     * @param blankToString 参数为空，返回的默认值
     * @return 返回字符串
     */
    public static String checkBlankToString(Object object, String blankToString) {
        return atLeastOneIsBlank(object) ? blankToString : object.toString();
    }

    /**
     * description: 一次性判断多个或单个对象至少有一个为空。
     * @param objects 可变数组
     * @return 只要有一个元素为Blank，则返回true。
     */
    public static Boolean atLeastOneIsBlank(Object...objects) {
        boolean result = false;
        for (Object object : objects) {
            if (object == null || object.toString().trim().isEmpty()
                    || "null".equals(object.toString().trim())
                    || "[]".equals(object.toString().trim())
                    || "[null]".equals(object.toString().trim())) {
                result = true;
                break;
            }
        }
        return result;
    }

    /**
     * description: 一次性判断多个或单个对象均不为空。
     * @param objects 可变数组
     * @return 所有元素均不为Blank，则返回true。
     */
    public static Boolean allIsNotBlank(Object...objects) {
        return !atLeastOneIsBlank(objects);
    }

    /**
     * description:  一次性判断多个或单个对象至少有一个不为空。
     * @param objects 可变数组
     * @return 只要有一个元素不为Blank，则返回true
     */
    public static Boolean atLeastOneIsNotBlank(Object...objects) {
        boolean result = false;
        for (Object object : objects) {
            if (null != object && !object.toString().trim().isEmpty()
                    && !"null".equals(object.toString().trim())
                    && !"[]".equals(object.toString().trim())
                    && !"[null]".equals(object.toString().trim())) {
                result = true;
                break;
            }
        }
        return result;
    }

    /**
     * description: 一次性判断多个或单个对象均为空。
     * @param objects 可变数组
     * @return 所有元素均为Blank，则返回true。
     */
    public static Boolean allIsBlank(Object...objects) {
        return !atLeastOneIsNotBlank(objects);
    }

    /**
     * description: 对字符串str进行md5加密获取信息摘要，即获取md5的信息摘要实例并对字符串str（字节数组）进行计算摘要
     * @param str String str = (System.currentTimeMillis() + new Random().nextInt(999999999)) + "";
     * @return 返回字符串
     */
    public static String stringToMd5(String str) {
        try {
            return new String(MessageDigest.getInstance("md5").digest(str.getBytes()));
        } catch (NoSuchAlgorithmException e) {
            log.error(e.getMessage());
            return "";
        }
    }

    /**
     * description: 使用md5的算法进行加密
     * @param plainText 内容
     * @return 返回字符串
     */
    public static String md5(String plainText) {
        byte[] secretBytes ;
        try {
            secretBytes = MessageDigest.getInstance("md5")
                    .digest(plainText.getBytes());
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("没有md5这个算法！");
        }
        // 16进制数字
        StringBuilder md5code = new StringBuilder(new BigInteger(1, secretBytes).toString(16));
        // 如果生成数字未满32位，需要前面补0
        for (int i = 0; i < 32 - md5code.length(); i++) {
            md5code.insert(0, "0");
        }
        return md5code.toString();
    }

    /**
     * description: 字符转换为ASCII码（字符转10进制数）
     * @param ch 字符
     * @return 返回10进制数
     */
    public static Integer charToAscii(char ch) {
        return ch & 0xffff;
    }

    /**
     * description: ASCII码转Unicode编码（10进制数转16进制数）
     * @param i 10进制数
     * @return 返回16进制数
     */
    public static String asciiToUnicode(int i) {
        return "\\u" + Integer.toHexString(i);
    }

    /**
     * description: 字符串转换为Unicode编码（字符串转16进制数）
     * @param str 字符串
     * @return 返回16进制数
     */
    public static String strToUnicode(String str) {
        StringBuilder s = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            // 字符转换为ASCII码
            int num = charToAscii(str.charAt(i));
            // ASCII码转Unicode编码
            s.append(asciiToUnicode(num));
        }
        return s.toString();
    }

    /**
     * description: 16进制数转字符
     * @param hex 16进制数
     * @return 字符
     */
    public static char hexToChar(String hex) {
        return (char) Integer.parseInt(hex, 16);
    }

    /**
     * description: 16进制数转10进制数
     * @param hex 16进制数
     * @return 10进制数
     */
    public static Integer hexToDecimal(String hex) {
        return Integer.parseInt(hex, 16);
    }

    /**
     * description: 10进制数转字符
     * @param decimal 10进制数
     * @return 字符
     */
    public static char decimalToChar(String decimal) {
        return (char)Integer.parseInt(decimal);
    }

    /**
     * description: HttpServletRequest请求数据转字符串，服务器端用request.getInputStream() 从流里面读JSON字符串
     * @param request http请求
     * @return 返回请求参数
     * @throws IOException 异常
     */
    public static String requestToString(HttpServletRequest request) throws IOException {
        StringBuilder sb = new StringBuilder();
        BufferedReader br = new BufferedReader(new InputStreamReader(request.getInputStream()));
        String line ;
        while ((line = br.readLine()) != null) {
            sb.append(line);
        }
        br.close();
        return sb.toString();
    }

    /**
     * description:  判断一个字符是否是中文
     * @param c 待验证字符
     * @return 是中文返回true，否则返回false
     */
    public static Boolean isChinese(char c) {
        // 判断该字符是否处于汉字字节码范围之内
        return c >= 0x4E00  && c <= 0x9FA5;
    }

    /**
     * description:  判断一个字符串是否含有中文
     * @param str 待验证字符串
     * @return 含有中文返回true，否则返回false
     */
    public static Boolean isChinese(String str) {
        if (str == null) {
            return false;
        }
        for (char c : str.toCharArray()) {
            if (isChinese(c)) {
                // 有一个中文字符就返回
                return true;
            }
        }
        return false;
    }

    /**
     * description: 替换字符串
     * @param str 字符串
     * @param nowStr 要被替换的字符串
     * @param replaceStr 用来替换的字符串
     * @return 返回字符串
     */
    public static String replaceString(String str, String nowStr, String replaceStr) {
        nowStr = atLeastOneIsBlank(nowStr) ? "" : nowStr;
        replaceStr = atLeastOneIsBlank(replaceStr) ? "" : replaceStr;
        if (atLeastOneIsNotBlank(str)) {
            return str.replace(nowStr, replaceStr);
        }
        return "";
    }

    /**
     * description: Double转字符串
     * @param d double
     * @return 字符串
     */
    public static String getDoubleToString(Double d) {
        String str = d.toString();
        if (!str.contains("E")) {
            return str;
        } else {
            BigDecimal bigDecimal = new BigDecimal(d.toString());
            return bigDecimal.toPlainString();
        }
    }

    /**
     * description: 字符串转换成其他数据类型
     * @param string 字符串
     * @param type 其他类型
     * @return 返回其他数据类型的数据
     */
    public static Object string2OtherType(String string, String type) {
        if (string == null || type == null) {
            return null;
        }
        Object object;
        switch (type) {
            case INTEGER:
                // 整型数据
                object = Integer.valueOf(string);
                break;
            case FLOAT:
                // 浮点型数据
                object = Float.valueOf(string);
                break;
            case DATE:
                // 日期型数据，只有日期没有时间
                object = CalendarUtil.stringToDate(string, "yyyy-MM-dd");
                break;
            case DATETIME:
                // 日期型数据，既有日期也有时间
                object = CalendarUtil.stringToDate(string, "yyyy-MM-dd HH:mm:ss");
                break;
            case BOOLEAN:
                // 布尔型数据
                object = Boolean.valueOf(string);
                break;
            default:
                object = null;
        }
        return object;
    }

    /**
     * description: 将以逗号分隔的字符串转换成字符串数组
     * @param valStr 以逗号分隔的字符串，形如："12,34,45,66,36"
     * @return 返回字符串数组
     */
    public static String[] string2Array(String valStr) {
        int i = 0;
        // 这步的目的是：将参数临时赋值，防止下面的replace操作改变valStr的本身。
        String tempStr = valStr;
        // 以逗号分隔的字符串形如："12,34,45,66,36"，其中逗号4个，而元素个数是5个
        String[] strArray = new String[valStr.length() + 1 - tempStr.replace(",", "").length()];
        valStr = valStr + ",";
        // 如果字符串valStr含有,字符
        while (valStr.indexOf(",") > 0) {
            //包含开头但不包含结尾
            strArray[i] = valStr.substring(0, valStr.indexOf(","));
            valStr = valStr.substring(valStr.indexOf(",") + 1);
            i++;
        }
        return strArray;
    }

    /**
     * 说明：主要是用来解决GET请求中文乱码问题（比如?name=张三）。
     * description: 字符编码转换
     * @param oldData 存在中文乱码的字符串
     * @return 返回没有中文乱码的字符串
     */
    public static String resolveMessy(String oldData) {
        String newData = "";
        try {
            newData = new String(oldData.getBytes(StandardCharsets.ISO_8859_1), StandardCharsets.UTF_8);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
        return newData;
    }

    /**
     * 说明：该方法没啥用！
     * description: 获取字符串的字符编码格式
     * @param str 字符串
     * @return 返回字符串的字符编码格式
     */
    public static String getEncoding(String str) throws Exception {
        String encoding = "ISO-8859-1";
        if (str.equals(new String(str.getBytes(encoding), encoding))) {
            return encoding;
        }
        encoding = "GB2312";
        if (str.equals(new String(str.getBytes(encoding), encoding))) {
            return encoding;
        }
        encoding = "GBK";
        if (str.equals(new String(str.getBytes(encoding), encoding))) {
            return encoding;
        }
        encoding = "UTF-8";
        if (str.equals(new String(str.getBytes(encoding), encoding))) {
            return encoding;
        }
        return "";
    }

    /**
     * 强调：对小数不适用
     * description: 阿拉伯数字转中文数字，仅限整数，示例：13015  ===>  "一万三千零一十五"
     * @param number 阿拉伯数字
     * @return 返回中文数字字符串
     */
    public static String numberToChinese(Integer number) {//转化一个阿拉伯数字为中文字符串
        if (number == 0) {
            return "零";
        }
        // 节权位标识
        int unitPos = 0;
        StringBuilder all = new StringBuilder();
        // 中文数字字符串
        String chineseNum = "";
        // 下一小结是否需要补零
        boolean needZero = false;
        String strIns;
        while (number > 0) {
            // 取最后面的那一个小节
            int section = number % 10000;
            // 判断上一小节千位是否为零，为零就要加上零
            if (needZero) {
                all.insert(0, TransferTool.chnNumChar[0]);
            }
            // 处理当前小节的数字，然后用chineseNum记录当前小节数字
            chineseNum = sectionToChinese(section, chineseNum);
            // 此处用if else 选择语句来执行加节权位
            if (section != 0) {
                // 当小节不为0，就加上节权位
                strIns = TransferTool.chnUnitSection[unitPos];
                chineseNum = chineseNum + strIns;
            } else {
                // 否则不用加
                strIns = TransferTool.chnUnitSection[0];
                chineseNum = strIns + chineseNum;
            }
            all.insert(0, chineseNum);
            chineseNum = "";
            needZero = (section < 1000) && (section > 0);
            number = number / 10000;
            unitPos++;
        }
        return all.toString();
    }

    /**
     * description: 处理当前小节的数字，然后用chineseNum记录当前小节数字
     * @param section 当前小节的数字
     * @param chineseNum 中文数字
     * @return 返回中文数字字符串
     */
    private static String sectionToChinese(int section, String chineseNum) {
        // 小节部分用独立函数操作
        String setionChinese;
        // 小节内部的权值计数器
        int unitPos = 0;
        // 小节内部的制零判断，每个小节内只能出现一个零
        boolean zero = true;
        StringBuilder chineseNumBuilder = new StringBuilder(chineseNum);
        while (section > 0) {
            // 取当前最末位的值
            int v = section % 10;
            if (v == 0) {
                if (!zero) {
                    // 需要补零的操作，确保对连续多个零只是输出一个
                    zero = true;
                    chineseNumBuilder.insert(0, TransferTool.chnNumChar[0]);
                }
            } else {
                // 有非零的数字，就把制零开关打开
                zero = false;
                // 对应中文数字位
                setionChinese = TransferTool.chnNumChar[v];
                // 对应中文权位
                setionChinese = setionChinese + TransferTool.chnUnitChar[unitPos];
                chineseNumBuilder.insert(0, setionChinese);
            }
            unitPos++;
            section = section / 10;
        }
        chineseNum = chineseNumBuilder.toString();
        return chineseNum;
    }

    /**
     * 强调：对小数不适用
     * description: 中文数字转阿拉伯数字，仅限整数，示例："一万三千零一十五"  ===>  13015
     * @param chinese 中文数字字符串
     * @return 返回阿拉伯数字
     */
    public static Integer chineseToNumber(String chinese) {
        String str1 = "";
        String str2 = "";
        String str3 = "";
        int k = 0;
        boolean dealflag = true;
        // 先把字符串中的“零”除去
        for (int i = 0; i < chinese.length(); i++) {
            if ('零' == (chinese.charAt(i))) {
                chinese = chinese.substring(0, i) + chinese.substring(i + 1);
            }
        }
        String chineseNum = chinese;
        for (int i = 0; i < chineseNum.length(); i++) {
            if (chineseNum.charAt(i) == '亿') {
                // 截取亿前面的数字，逐个对照表格，然后转换
                str1 = chineseNum.substring(0, i);
                k = i + 1;
                // 已经处理
                dealflag = false;
            }
            if (chineseNum.charAt(i) == '万') {
                str2 = chineseNum.substring(k, i);
                str3 = chinese.substring(i + 1);
                // 已经处理
                dealflag = false;
            }
        }
        // 如果没有处理
        if (dealflag) {
            str3 =  chineseNum;
        }
        return sectionChinese(str1) * 100000000 +
                sectionChinese(str2) * 10000 + sectionChinese(str3);
    }

    /**
     * description: 中文数字字符串转阿拉伯数字
     * @param str 中文数字字符串
     * @return 返回阿拉伯数字
     */
    private static Integer sectionChinese(String str) {
        int value = 0;
        int sectionNum = 0;
        for (int i = 0; i < str.length(); i++) {
            int v = (int) TransferTool.intList.get(str.charAt(i));
            // 如果数值是权位则相乘
            if ( v == 10 || v == 100 || v == 1000 ) {
                sectionNum = v * sectionNum;
                value = value + sectionNum;
            } else if (i == str.length() - 1) {
                value = value + v;
            } else {
                sectionNum = v;
            }
        }
        return value;
    }

    /**
     * description: 将手机号中间4位替换成4位*，比如将18776549876中间4位替换成4位*变成187****9876
     * @author 朱正磊
     * @date 2022-01-19 11:50:09
     * @param phone 手机号
     * @return 返回加星手机号
     */
    public static String getStarPhone(String phone) {
        if (EmptyUtil.isEmpty(phone)) {
            throw new RuntimeException("手机号不允许为空！");
        }
        return phone.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
    }

    /**
     * description: 将18位身份证号中间10位替换成4位*，比如123456789987654321中间10位替换成4位*变成1234****4321
     * @author 朱正磊
     * @date 2022-01-19 11:56:39
     * @param idCard 身份证号
     * @return 返回加星身份证号
     */
    public static String getStarIdCard(String idCard) {
        if (EmptyUtil.isEmpty(idCard)) {
            throw new RuntimeException("身份证号不允许为空！");
        }
        return idCard.replaceAll("(\\d{4})\\d{10}(\\w{4})", "$1****$2");
    }

    /**
     * description: 对中文名字进行脱敏，比如朱正磊会转换成朱*磊，张三会转换成张*
     * @author 朱正磊
     * @date 2023-08-25 16:42:13
     * @param chineseName 中文名字
     * @return 返回加星中文名字
     */
    public static String getStarChineseName(String chineseName) {
        if (EmptyUtil.isEmpty(chineseName)) {
            // 需要进行脱敏的中文名字不能为空
            throw new RuntimeException("中文名字不允许为空！");
        }
        if (chineseName.contains("*")) {
            // 已结脱敏过的中文名字不再进行脱敏，直接返回
            return chineseName;
        }
        String newName = "";
        char[] chars = chineseName.toCharArray();
        if (chars.length == 1) {
            newName = chineseName;
        } else if (chars.length == 2) {
            newName = chineseName.replace(chineseName.substring(1), "*");
        } else if (chars.length > 2) {
            newName = chineseName.replace(chineseName.substring(1, chars.length - 1), "*");
        }
        return newName;
    }

    /**
     * description: 使用正则表达式来判断字符串中是否包含英文字母
     * @author 朱正磊
     * @date 2022-05-19 17:51:26
     * @param content 待检验的字符串
     * @return 返回true表示包含英文字母；返回false表示不包含英文字母
     */
    public static Boolean judgeContainsLetter(String content) {
        String regex = ".*[a-zA-Z]+.*";
        Matcher matcher = Pattern.compile(regex).matcher(content);
        return matcher.matches();
    }

    /**
     * 1234.56 → 壹仟贰佰叁拾肆元伍角陆分
     * 100000000.01 → 壹亿元零壹分
     * 0.78 → 零元柒角捌分
     * 1001.01 → 壹仟零壹元零壹分
     * 10000.00 → 壹万元整
     * -56.78 → 负伍拾陆元柒角捌分
     * <p>
     * description: 将金额数字字符串转换为中文大写，小数位转角分
     * @author 朱正磊
     * @date 2025-07-18 15:55:07
     * @param amount 金额数字字符串
     * @return 中文大写金额
     */
    public static String numToCny(String amount) {
        return numToCny(Double.parseDouble(amount));
    }

    /**
     * 1234.56 → 壹仟贰佰叁拾肆元伍角陆分
     * 100000000.01 → 壹亿元零壹分
     * 0.78 → 零元柒角捌分
     * 1001.01 → 壹仟零壹元零壹分
     * 10000.00 → 壹万元整
     * -56.78 → 负伍拾陆元柒角捌分
     * <p>
     * description: 将金额数字转换为中文大写，小数位转角分
     * @author 朱正磊
     * @date 2025-07-18 15:55:07
     * @param amount 金额数字
     * @return 中文大写金额
     */
    public static String numToCny(double amount) {
        // 处理负数
        if (amount < 0) {
            return "负" + numToCny(-amount);
        }

        // 分离整数和小数部分
        long integerPart = (long) amount;
        // 四舍五入到分
        int decimalPart = (int) Math.round((amount - integerPart) * 100);

        // 中文数字和单位
        String[] chineseNums = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
        String[] chineseUnits = {"", "拾", "佰", "仟", "万", "拾", "佰", "仟", "亿", "拾", "佰", "仟", "万"};

        // 转换整数部分
        StringBuilder integerChinese = new StringBuilder();
        if (integerPart == 0) {
            integerChinese.append("零");
        } else {
            int unitIndex = 0;
            // 标记前一位是否为零
            boolean zeroFlag = true;

            while (integerPart > 0) {
                int digit = (int) (integerPart % 10);
                if (digit == 0) {
                    if (!zeroFlag) {
                        // 避免连续的零
                        integerChinese.insert(0, chineseNums[digit]);
                        zeroFlag = true;
                    }
                } else {
                    integerChinese.insert(0, chineseNums[digit] + chineseUnits[unitIndex]);
                    zeroFlag = false;
                }

                integerPart = integerPart / 10;
                unitIndex++;
            }

            // 处理万亿连接处的零（如 100000000 应读为 壹亿，而非 壹亿万）
            String result = integerChinese.toString();
            result = result.replace("零万", "万");
            result = result.replace("零亿", "亿");
            // 移除末尾的零
            if (result.endsWith("零")) {
                result = result.substring(0, result.length() - 1);
            }
            integerChinese = new StringBuilder(result);
        }

        // 转换小数部分（角分）
        int jiao = decimalPart / 10;
        int fen = decimalPart % 10;

        StringBuilder decimalChinese = new StringBuilder();
        if (jiao == 0 && fen == 0) {
            decimalChinese.append("整");
        } else {
            if (jiao > 0) {
                decimalChinese.append(chineseNums[jiao]).append("角");
            }
            if (fen > 0) {
                decimalChinese.append(chineseNums[fen]).append("分");
            }
        }

        // 组合结果
        return integerChinese + "元" + decimalChinese;
    }

}
